/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package br.com.foxinline.manager.pesquisar;

import br.com.foxinline.enums.TipoDocumento;
import br.com.foxinline.modelo.*;
import br.com.foxinline.servico.AnexoServico;
import br.com.foxinline.servico.FolhaPagamentoServico;
import br.com.foxinline.servico.PessoaServico;
import br.com.foxinline.servico.SecretariaServico;
import br.com.foxinline.util.Msg;
import br.com.foxinline.utilitarios.ArquivoUtilitario;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Serializable;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.PostConstruct;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;
import org.primefaces.context.RequestContext;
import org.primefaces.event.FileUploadEvent;

/**
 *
 * @author laverson
 */
@ViewScoped
@ManagedBean
public class ManagerPesquisarFolhaPagamento implements Serializable {

    @EJB
    PessoaServico pessoaServico;
    @EJB
    FolhaPagamentoServico folhaPagamentoServico;
    @EJB
    AnexoServico anexoServico;
    @EJB
    SecretariaServico secretariaServico;
    private Pessoa funcionarioPesquisar;
    private Pessoa funcionarioEditar;
    private Secretaria secretariaPesquisar;
    private Secretaria secretariaPesquisarDialog;
    private Secretaria secretariaEditar;
    private Secretaria secretariaVisualizar;
    private Secretaria secretariaPesquisarEditar;
    private List<Secretaria> secretarias;
    private List<Secretaria> secretariasEditar;
    private FolhaPagamento folhaPagamentoPesquisar;
    private FolhaPagamento folhaPagamentoEditar;
    private FolhaPagamento folhaPagamentoVisualizar;
    private FolhaPagamento folhaPagamentoDeletar;
    private List<FolhaPagamento> folhasPagamentos;
    private ItemFolhaPagamento itemFolhaPagamentoEditar;
    private List<ItemFolhaPagamento> itensFolhaPagamentoEditar;
    private List<ItemFolhaPagamento> itensFolhaPagamentoVisualizar;
    private ArquivoUtilitario arquivoUtilitario = new ArquivoUtilitario();
    private String eFolhaPagamento;
    private String vFolhaPagamento;
    private List<Anexo> anexosRemover = new ArrayList<Anexo>();
    private List<Anexo> anexos;
    private static final String msgFailure = ":: Erro de validação: o valor é necessário.";

    @PostConstruct
    public void init() {
        folhaPagamentoPesquisar = new FolhaPagamento();
        folhaPagamentoPesquisar.setAnexos(new ArrayList<Anexo>());

        secretariaPesquisar = new Secretaria();
        secretariaPesquisarDialog = new Secretaria();
        funcionarioPesquisar = iniciarFuncionario();
        Map<String, String> params = FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap();
        eFolhaPagamento = params.get("eFolhaPagamento");
        vFolhaPagamento = params.get("vFolhaPagamento");
        paramPost();
    }

    public void paramPost() {
        try {
            if (eFolhaPagamento != null) {
                folhaPagamentoEditar = folhaPagamentoServico.pesquisar(Long.parseLong(eFolhaPagamento));

//                List<Anexo> anexos = folhaPagamentoEditar.getAnexos();
                anexos = folhaPagamentoEditar.getAnexos() != null ? folhaPagamentoEditar.getAnexos() : new ArrayList<Anexo>();

                itemFolhaPagamentoEditar = new ItemFolhaPagamento();

                List<ItemFolhaPagamento> itens = folhaPagamentoEditar.getItensFolhaPagamento();
                itensFolhaPagamentoEditar = itens != null ? itens : new ArrayList<ItemFolhaPagamento>();

                funcionarioEditar = iniciarFuncionario();

                secretariaEditar = folhaPagamentoEditar.getSecretaria() != null ? folhaPagamentoEditar.getSecretaria() : new Secretaria();
                secretariaPesquisarEditar = new Secretaria();
            }
            if (vFolhaPagamento != null) {
                folhaPagamentoVisualizar = folhaPagamentoServico.pesquisar(Long.parseLong(vFolhaPagamento));

                List<ItemFolhaPagamento> itens = folhaPagamentoVisualizar.getItensFolhaPagamento();
                itensFolhaPagamentoVisualizar = itens != null ? itens : new ArrayList<ItemFolhaPagamento>();
                secretariaVisualizar = folhaPagamentoVisualizar.getSecretaria() != null ? folhaPagamentoVisualizar.getSecretaria() : new Secretaria();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void pesquisar() {
        folhasPagamentos = folhaPagamentoServico.pesquisar(folhaPagamentoPesquisar, funcionarioPesquisar);
    }

    public void atualizar() {
        try {
            folhaPagamentoEditar.setItensFolhaPagamento(itensFolhaPagamentoEditar);

            if (secretariaEditar != null && secretariaEditar.getId() != null) {

                if (!folhaPagamentoEditar.getItensFolhaPagamento().isEmpty()) {

                    System.err.println("Anexos = " + anexos);
                    if (!anexos.isEmpty()) {
                        arquivoUtilitario.gravarAnexos(anexos);
                        anexos = arquivoUtilitario.removerBytes(anexos);
                        folhaPagamentoEditar.setAnexos(anexos);
                    }
                    System.err.println("Anexos FP = " + folhaPagamentoEditar.getAnexos());

                    folhaPagamentoEditar.setItensFolhaPagamento(itensFolhaPagamentoEditar);
                    folhaPagamentoServico.atualizar(folhaPagamentoEditar);

                    for (Anexo a : anexosRemover) {
                        arquivoUtilitario.excluirArquivo(new File(a.getUrl() + a.getNome()));
                    }

                    Msg.messagemInfo(Msg.SuccessFull);
                } else {
                    Msg.messagemError("Informe pelo menos um item para a Folha de Pagamento !");
                }
            } else {
                Msg.messagemError("Secretaria" + msgFailure);
                RequestContext.getCurrentInstance().execute("requiredSecretaria(true)");
            }
        } catch (Exception e) {
            e.printStackTrace();
            Msg.messagemError(Msg.Failure);
        }
    }

    public void deletar() {
        try {
            this.folhasPagamentos.remove(this.folhaPagamentoDeletar);
            this.folhaPagamentoServico.remover(this.folhaPagamentoDeletar);
            Msg.messagemInfo(Msg.SuccessFull);
        } catch (Exception e) {
            e.printStackTrace();
            Msg.messagemError(Msg.Failure);
        }
    }

    public void existeCliente() {
        Pessoa p = this.pessoaServico.existProprietario(this.funcionarioEditar);

        if (p != null) {
            this.funcionarioEditar = p;
        } else {
            this.funcionarioEditar.setId(null);
        }
    }

    public List<SelectItem> getTipoDocumento() {
        List<SelectItem> items = new ArrayList<SelectItem>();
        for (TipoDocumento tipo : TipoDocumento.values()) {
            items.add(new SelectItem(tipo, tipo.getNome()));
        }
        return items;
    }

    public String dataFolhaPagamento(FolhaPagamento folhaPagamento) {
        if (folhaPagamento != null) {
            if (folhaPagamento.getDataFolhaPagamento() != null) {
                return new SimpleDateFormat("dd/MM/yyyy").format(folhaPagamento.getDataFolhaPagamento());
            }
        }
        return null;
    }

    public String dataFolhaPagamento() {
        if (eFolhaPagamento != null) {
            if (folhaPagamentoEditar.getDataFolhaPagamento() != null) {
                return new SimpleDateFormat("dd/MM/yyyy").format(folhaPagamentoEditar.getDataFolhaPagamento());
            }
        }
        return null;
    }

    public String dataNascimento() {
        if (this.funcionarioEditar.getDataNascimento() != null) {
            return new SimpleDateFormat("dd/MM/yyyy").format(this.funcionarioEditar.getDataNascimento());
        }
        return null;
    }
    private static int tamanhoMaximoNome = 10;

    public String nomeAnexo(Anexo a) {
        if (a.getNomeExibicao().length() >= tamanhoMaximoNome) {
            return a.getNomeExibicao().substring(0, tamanhoMaximoNome).concat("...");
        }
        return a.getNomeExibicao().replace(".png", "").replace(" ", "_");
    }

    public String nomeAnexoPdf(Anexo a) {
        if (a.getNomeExibicao().length() >= tamanhoMaximoNome) {
            return a.getNomeExibicao().substring(0, tamanhoMaximoNome).concat("...");
        }
        return a.getNomeExibicao().replace(".pdf", "").replace(" ", "_");
    }

    public void handleAnnex(FileUploadEvent event) throws IOException {
        try {
            anexos.add(arquivoUtilitario.adicionarArquivo(event));
        } catch (FileNotFoundException ex) {
            Logger.getLogger(ManagerPesquisarFolhaPagamento.class.getName()).log(Level.SEVERE, null, ex);
        } catch (SQLException ex) {
            Logger.getLogger(ManagerPesquisarFolhaPagamento.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Remove o anexo da lista de anexos do processo que está sendo adicionado e
     * remove o arquivo do diretório que foi gravado
     *
     * @param anexo
     */
    public void removerAnexo(Anexo anexo) {
        try {
            anexosRemover.add(anexo);
            folhaPagamentoEditar.getAnexos().remove(anexo);
        } catch (Exception e) {
            Msg.messagemError(Msg.Failure);
        }
    }

    public void adicionarItemFolhaPagamento() {
        if (funcionarioValido()) {
            this.itemFolhaPagamentoEditar.setPessoa(this.funcionarioEditar);

            if (!this.itensFolhaPagamentoEditar.contains(this.itemFolhaPagamentoEditar)) {
                this.itensFolhaPagamentoEditar.add(this.itemFolhaPagamentoEditar);
            }

            this.funcionarioEditar = iniciarFuncionario();
            this.itemFolhaPagamentoEditar = new ItemFolhaPagamento();
        } else {
            RequestContext.getCurrentInstance().execute("requiredFuncionario(true)");
        }
    }

    public void editarItemFolhaPagamento(ItemFolhaPagamento itemFolhaPagamento) {
        this.itemFolhaPagamentoEditar = itemFolhaPagamento;
        this.funcionarioEditar = itemFolhaPagamento.getPessoa();
        this.itensFolhaPagamentoEditar.remove(itemFolhaPagamento);
    }

    public void removerSecretaria() {
        if (this.eFolhaPagamento != null) {
            this.secretariaEditar = new Secretaria();
        }
        this.secretariaPesquisar = new Secretaria();
    }

    public void removerFolhaPagamento(ItemFolhaPagamento folhaPagamento) {
        this.itensFolhaPagamentoEditar.remove(folhaPagamento);
    }

    public void setarSecretaria(Secretaria secretaria) {
        this.secretariaPesquisar = secretaria;
    }

    private boolean funcionarioValido() {
        if (isPessoaFisica()) {
            if (this.funcionarioEditar.getCpf() == null || this.funcionarioEditar.getCpf().equals("")) {
                Msg.messagemError("CPF".concat(msgFailure));
            }
            if (this.funcionarioEditar.getNome() == null || this.funcionarioEditar.getNome().equals("")) {
                Msg.messagemError("Nome".concat(msgFailure));
            }
            if ((this.funcionarioEditar.getCpf() == null || this.funcionarioEditar.getCpf().equals("")) || (this.funcionarioEditar.getNome() == null || this.funcionarioEditar.getNome().equals(""))) {
                return false;
            }
        } else {
            if (this.funcionarioEditar.getCnpj() == null || this.funcionarioEditar.getCnpj().equals("")) {
                Msg.messagemError("CNPJ".concat(msgFailure));
            }
            if (this.funcionarioEditar.getNomeFantasia() == null || this.funcionarioEditar.getNomeFantasia().equals("")) {
                Msg.messagemError("Nome Fantasia".concat(msgFailure));
            }
            if ((this.funcionarioEditar.getCnpj() == null || this.funcionarioEditar.getCnpj().equals("")) || (this.funcionarioEditar.getNomeFantasia() == null || this.funcionarioEditar.getNomeFantasia().equals(""))) {
                return false;
            }
        }
        return true;
    }

    public void pesquisarSecretaria() {
        this.secretarias = secretariaServico.pesquisarSecretaria(this.secretariaPesquisarDialog);
    }

    public Pessoa iniciarFuncionario() {
        Pessoa funcionario = new Pessoa();
        funcionario.setTipoDocumento(TipoDocumento.CPF);
        return funcionario;
    }

    public boolean isPessoaFisica() {
        return funcionarioEditar.getTipoDocumento().equals(TipoDocumento.CPF);
    }

    public boolean isPessoaFisicaPesquisar() {
        return funcionarioPesquisar.getTipoDocumento().equals(TipoDocumento.CPF);
    }

    public FolhaPagamento getFolhaPagamentoEditar() {
        return folhaPagamentoEditar;
    }

    public void setFolhaPagamentoEditar(FolhaPagamento folhaPagamentoEditar) {
        this.folhaPagamentoEditar = folhaPagamentoEditar;
    }

    public FolhaPagamento getFolhaPagamentoPesquisar() {
        return folhaPagamentoPesquisar;
    }

    public void setFolhaPagamentoPesquisar(FolhaPagamento folhaPagamentoPesquisar) {
        this.folhaPagamentoPesquisar = folhaPagamentoPesquisar;
    }

    public FolhaPagamento getFolhaPagamentoVisualizar() {
        return folhaPagamentoVisualizar;
    }

    public void setFolhaPagamentoVisualizar(FolhaPagamento folhaPagamentoVisualizar) {
        this.folhaPagamentoVisualizar = folhaPagamentoVisualizar;
    }

    public List<FolhaPagamento> getFolhasPagamentos() {
        return folhasPagamentos;
    }

    public void setFolhasPagamentos(List<FolhaPagamento> folhasPagamentos) {
        this.folhasPagamentos = folhasPagamentos;
    }

    public Pessoa getFuncionarioEditar() {
        return funcionarioEditar;
    }

    public void setFuncionarioEditar(Pessoa funcionarioEditar) {
        this.funcionarioEditar = funcionarioEditar;
    }

    public Pessoa getFuncionarioPesquisar() {
        return funcionarioPesquisar;
    }

    public void setFuncionarioPesquisar(Pessoa funcionarioPesquisar) {
        this.funcionarioPesquisar = funcionarioPesquisar;
    }

    public ItemFolhaPagamento getItemFolhaPagamentoEditar() {
        return itemFolhaPagamentoEditar;
    }

    public void setItemFolhaPagamentoEditar(ItemFolhaPagamento itemFolhaPagamentoEditar) {
        this.itemFolhaPagamentoEditar = itemFolhaPagamentoEditar;
    }

    public List<ItemFolhaPagamento> getItensFolhaPagamentoEditar() {
        return itensFolhaPagamentoEditar;
    }

    public void setItensFolhaPagamentoEditar(List<ItemFolhaPagamento> itensFolhaPagamentoEditar) {
        this.itensFolhaPagamentoEditar = itensFolhaPagamentoEditar;
    }

    public List<ItemFolhaPagamento> getItensFolhaPagamentoVisualizar() {
        return itensFolhaPagamentoVisualizar;
    }

    public void setItensFolhaPagamentoVisualizar(List<ItemFolhaPagamento> itensFolhaPagamentoVisualizar) {
        this.itensFolhaPagamentoVisualizar = itensFolhaPagamentoVisualizar;
    }

    public FolhaPagamento getFolhaPagamentoDeletar() {
        return folhaPagamentoDeletar;
    }

    public void setFolhaPagamentoDeletar(FolhaPagamento folhaPagamentoDeletar) {
        this.folhaPagamentoDeletar = folhaPagamentoDeletar;
    }

    public Secretaria getSecretariaEditar() {
        return secretariaEditar;
    }

    public void setSecretariaEditar(Secretaria secretariaEditar) {
        this.secretariaEditar = secretariaEditar;
    }

    public Secretaria getSecretariaPesquisar() {
        return secretariaPesquisar;
    }

    public void setSecretariaPesquisar(Secretaria secretariaPesquisar) {
        this.secretariaPesquisar = secretariaPesquisar;
    }

    public Secretaria getSecretariaPesquisarDialog() {
        return secretariaPesquisarDialog;
    }

    public void setSecretariaPesquisarDialog(Secretaria secretariaPesquisarDialog) {
        this.secretariaPesquisarDialog = secretariaPesquisarDialog;
    }

    public Secretaria getSecretariaVisualizar() {
        return secretariaVisualizar;
    }

    public void setSecretariaVisualizar(Secretaria secretariaVisualizar) {
        this.secretariaVisualizar = secretariaVisualizar;
    }

    public Secretaria getSecretariaPesquisarEditar() {
        return secretariaPesquisarEditar;
    }

    public void setSecretariaPesquisarEditar(Secretaria secretariaPesquisarEditar) {
        this.secretariaPesquisarEditar = secretariaPesquisarEditar;
    }

    public List<Secretaria> getSecretarias() {
        return secretarias;
    }

    public void setSecretarias(List<Secretaria> secretarias) {
        this.secretarias = secretarias;
    }

    public List<Secretaria> getSecretariasEditar() {
        return secretariasEditar;
    }

    public void setSecretariasEditar(List<Secretaria> secretariasEditar) {
        this.secretariasEditar = secretariasEditar;
    }

    public List<Anexo> getAnexosRemover() {
        return anexosRemover;
    }

    public void setAnexosRemover(List<Anexo> anexosRemover) {
        this.anexosRemover = anexosRemover;
    }

    public List<Anexo> getAnexos() {
        return anexos;
    }

    public void setAnexos(List<Anexo> anexos) {
        this.anexos = anexos;
    }
}
